﻿///////////////////////////////////////////////////////////////
// This is generated code. If you modify this code, be aware
// of the fact that when you re-generate the code, your changes
// are lost. If you want to keep your changes, make this file read-only
// when you have finished your changes, however it is recommended that
// you inherit from this class to extend the functionality of this generated
// class or you modify / extend the templates used to generate this code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 1.0.2005.1
// Code is generated on: October 21, 2008 12:02:15 AM
// Code is generated using templates: C# template set for SqlServer (1.0.2005.1)
// Templates vendor: Solutions Design.
// Templates version: 1.0.2005.1.111705
//////////////////////////////////////////////////////////////
using System;

using Ultimate.DAL;

using SD.LLBLGen.Pro.ORMSupportClasses;

namespace Ultimate.DAL.FactoryClasses
{
	/// <summary>
	/// Class which eases the creation of the different predicate clauses defined in the ORM support classes. 
	/// Use these methods to create predicate clauses for filters without a lot of code.
	/// </summary>
	public partial class PredicateFactory
	{
		/// <summary>
		/// Static class, no CTor
		/// </summary>
		private PredicateFactory()
		{
		}

		#region FieldCompareValuePredicate creators (4 per entity type)

		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, negate);
		}

		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareValuePredicate CompareValue(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, object value, string objectAlias, bool negate)
		{
			return new FieldCompareValuePredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, value, objectAlias, negate);
		}
		#endregion

		#region FieldCompareValuePredicate creators (4 per typed view type)

		#endregion

		#region FieldCompareNullPredicate creators (4 per entity type)

		/// <summary>FieldCompareNullPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Aspnet_UsersFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Aspnet_UsersFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Aspnet_UsersFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Aspnet_UsersFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Cs_UsersFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Cs_UsersFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Cs_UsersFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(Cs_UsersFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for FieldEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(FieldFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for FieldEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(FieldFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for FieldEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(FieldFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for FieldEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(FieldFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for GameEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(GameFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for GameEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(GameFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for GameEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(GameFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for GameEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(GameFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for LeagueEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LeagueFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for LeagueEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LeagueFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for LeagueEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LeagueFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for LeagueEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LeagueFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for LocationEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LocationFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for LocationEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LocationFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for LocationEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LocationFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for LocationEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(LocationFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for PlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(PlayerFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for PlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(PlayerFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for PlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(PlayerFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for PlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(PlayerFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for RoleEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(RoleFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for RoleEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(RoleFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for RoleEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(RoleFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for RoleEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(RoleFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for TeamEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for TeamEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for TeamEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for TeamEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		/// <summary>FieldCompareNullPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamPlayerFieldIndex indexOfField)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField));
		}

		/// <summary>FieldCompareNullPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamPlayerFieldIndex indexOfField, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), negate);
		}

		/// <summary>FieldCompareNullPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamPlayerFieldIndex indexOfField, string objectAlias)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias);
		}

		/// <summary>FieldCompareNullPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareNullPredicate CompareNull(TeamPlayerFieldIndex indexOfField, string objectAlias, bool negate)
		{
			return new FieldCompareNullPredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate);
		}
		#endregion

		#region FieldCompareNullPredicate creators (4 per typed view type)

		#endregion

		#region FieldBetweenPredicate creators (4 per entity type)

		/// <summary>FieldBetweenPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Aspnet_UsersFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Aspnet_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Aspnet_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Aspnet_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for Cs_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Cs_UsersFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for Cs_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Cs_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for Cs_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Cs_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for Cs_UsersEntity.</summary>
		public static FieldBetweenPredicate Between(Cs_UsersFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for FieldEntity.</summary>
		public static FieldBetweenPredicate Between(FieldFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for FieldEntity.</summary>
		public static FieldBetweenPredicate Between(FieldFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for FieldEntity.</summary>
		public static FieldBetweenPredicate Between(FieldFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for FieldEntity.</summary>
		public static FieldBetweenPredicate Between(FieldFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for GameEntity.</summary>
		public static FieldBetweenPredicate Between(GameFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for GameEntity.</summary>
		public static FieldBetweenPredicate Between(GameFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for GameEntity.</summary>
		public static FieldBetweenPredicate Between(GameFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for GameEntity.</summary>
		public static FieldBetweenPredicate Between(GameFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for LeagueEntity.</summary>
		public static FieldBetweenPredicate Between(LeagueFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for LeagueEntity.</summary>
		public static FieldBetweenPredicate Between(LeagueFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for LeagueEntity.</summary>
		public static FieldBetweenPredicate Between(LeagueFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for LeagueEntity.</summary>
		public static FieldBetweenPredicate Between(LeagueFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for LocationEntity.</summary>
		public static FieldBetweenPredicate Between(LocationFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for LocationEntity.</summary>
		public static FieldBetweenPredicate Between(LocationFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for LocationEntity.</summary>
		public static FieldBetweenPredicate Between(LocationFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for LocationEntity.</summary>
		public static FieldBetweenPredicate Between(LocationFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for PlayerEntity.</summary>
		public static FieldBetweenPredicate Between(PlayerFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for PlayerEntity.</summary>
		public static FieldBetweenPredicate Between(PlayerFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for PlayerEntity.</summary>
		public static FieldBetweenPredicate Between(PlayerFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for PlayerEntity.</summary>
		public static FieldBetweenPredicate Between(PlayerFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for RoleEntity.</summary>
		public static FieldBetweenPredicate Between(RoleFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for RoleEntity.</summary>
		public static FieldBetweenPredicate Between(RoleFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for RoleEntity.</summary>
		public static FieldBetweenPredicate Between(RoleFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for RoleEntity.</summary>
		public static FieldBetweenPredicate Between(RoleFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for TeamEntity.</summary>
		public static FieldBetweenPredicate Between(TeamFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for TeamEntity.</summary>
		public static FieldBetweenPredicate Between(TeamFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for TeamEntity.</summary>
		public static FieldBetweenPredicate Between(TeamFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for TeamEntity.</summary>
		public static FieldBetweenPredicate Between(TeamFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		/// <summary>FieldBetweenPredicate factory for TeamPlayerEntity.</summary>
		public static FieldBetweenPredicate Between(TeamPlayerFieldIndex indexOfField, object valueBegin, object valueEnd)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd);
		}

		/// <summary>FieldBetweenPredicate factory for TeamPlayerEntity.</summary>
		public static FieldBetweenPredicate Between(TeamPlayerFieldIndex indexOfField, object valueBegin, object valueEnd, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, negate);
		}

		/// <summary>FieldBetweenPredicate factory for TeamPlayerEntity.</summary>
		public static FieldBetweenPredicate Between(TeamPlayerFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias);
		}

		/// <summary>FieldBetweenPredicate factory for TeamPlayerEntity.</summary>
		public static FieldBetweenPredicate Between(TeamPlayerFieldIndex indexOfField, object valueBegin, object valueEnd, string objectAlias, bool negate)
		{
			return new FieldBetweenPredicate(EntityFieldFactory.Create(indexOfField), valueBegin, valueEnd, objectAlias, negate);
		}
		#endregion

		#region FieldBetweenPredicate creators (4 per typed view type)

		#endregion

		#region FieldLikePredicate creators (4 per entity type)

		/// <summary>FieldLikePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldLikePredicate Like(Aspnet_UsersFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldLikePredicate Like(Aspnet_UsersFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldLikePredicate Like(Aspnet_UsersFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldLikePredicate Like(Aspnet_UsersFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for Cs_UsersEntity.</summary>
		public static FieldLikePredicate Like(Cs_UsersFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for Cs_UsersEntity.</summary>
		public static FieldLikePredicate Like(Cs_UsersFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for Cs_UsersEntity.</summary>
		public static FieldLikePredicate Like(Cs_UsersFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for Cs_UsersEntity.</summary>
		public static FieldLikePredicate Like(Cs_UsersFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for FieldEntity.</summary>
		public static FieldLikePredicate Like(FieldFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for FieldEntity.</summary>
		public static FieldLikePredicate Like(FieldFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for FieldEntity.</summary>
		public static FieldLikePredicate Like(FieldFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for FieldEntity.</summary>
		public static FieldLikePredicate Like(FieldFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for GameEntity.</summary>
		public static FieldLikePredicate Like(GameFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for GameEntity.</summary>
		public static FieldLikePredicate Like(GameFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for GameEntity.</summary>
		public static FieldLikePredicate Like(GameFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for GameEntity.</summary>
		public static FieldLikePredicate Like(GameFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for LeagueEntity.</summary>
		public static FieldLikePredicate Like(LeagueFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for LeagueEntity.</summary>
		public static FieldLikePredicate Like(LeagueFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for LeagueEntity.</summary>
		public static FieldLikePredicate Like(LeagueFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for LeagueEntity.</summary>
		public static FieldLikePredicate Like(LeagueFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for LocationEntity.</summary>
		public static FieldLikePredicate Like(LocationFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for LocationEntity.</summary>
		public static FieldLikePredicate Like(LocationFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for LocationEntity.</summary>
		public static FieldLikePredicate Like(LocationFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for LocationEntity.</summary>
		public static FieldLikePredicate Like(LocationFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for PlayerEntity.</summary>
		public static FieldLikePredicate Like(PlayerFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for PlayerEntity.</summary>
		public static FieldLikePredicate Like(PlayerFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for PlayerEntity.</summary>
		public static FieldLikePredicate Like(PlayerFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for PlayerEntity.</summary>
		public static FieldLikePredicate Like(PlayerFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for RoleEntity.</summary>
		public static FieldLikePredicate Like(RoleFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for RoleEntity.</summary>
		public static FieldLikePredicate Like(RoleFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for RoleEntity.</summary>
		public static FieldLikePredicate Like(RoleFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for RoleEntity.</summary>
		public static FieldLikePredicate Like(RoleFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for TeamEntity.</summary>
		public static FieldLikePredicate Like(TeamFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for TeamEntity.</summary>
		public static FieldLikePredicate Like(TeamFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for TeamEntity.</summary>
		public static FieldLikePredicate Like(TeamFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for TeamEntity.</summary>
		public static FieldLikePredicate Like(TeamFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		/// <summary>FieldLikePredicate factory for TeamPlayerEntity.</summary>
		public static FieldLikePredicate Like(TeamPlayerFieldIndex indexOfField, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern);
		}

		/// <summary>FieldLikePredicate factory for TeamPlayerEntity.</summary>
		public static FieldLikePredicate Like(TeamPlayerFieldIndex indexOfField, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), pattern, negate);
		}

		/// <summary>FieldLikePredicate factory for TeamPlayerEntity.</summary>
		public static FieldLikePredicate Like(TeamPlayerFieldIndex indexOfField, string objectAlias, string pattern)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern);
		}

		/// <summary>FieldLikePredicate factory for TeamPlayerEntity.</summary>
		public static FieldLikePredicate Like(TeamPlayerFieldIndex indexOfField, string objectAlias, string pattern, bool negate)
		{
			return new FieldLikePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, pattern, negate);
		}
		#endregion

		#region FieldLikePredicate creators (4 per typed view type)

		#endregion
		
		
		#region FieldCompareRangePredicate creators (4 per entity type)

		/// <summary>FieldCompareRangePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Aspnet_UsersFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Aspnet_UsersFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Aspnet_UsersFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Aspnet_UsersFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Cs_UsersFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Cs_UsersFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Cs_UsersFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(Cs_UsersFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for FieldEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(FieldFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(FieldFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for FieldEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(FieldFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for FieldEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(FieldFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for GameEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(GameFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(GameFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for GameEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(GameFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for GameEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(GameFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for LeagueEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LeagueFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LeagueFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for LeagueEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LeagueFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LeagueEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LeagueFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for LocationEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LocationFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LocationFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for LocationEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LocationFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for LocationEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(LocationFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for PlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(PlayerFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(PlayerFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for PlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(PlayerFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for PlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(PlayerFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for RoleEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(RoleFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(RoleFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for RoleEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(RoleFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for RoleEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(RoleFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for TeamEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for TeamEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		/// <summary>FieldCompareRangePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamPlayerFieldIndex indexOfField, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamPlayerFieldIndex indexOfField, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), negate, values);
		}

		/// <summary>FieldCompareRangePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamPlayerFieldIndex indexOfField, string objectAlias, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, values);
		}
		
		/// <summary>FieldCompareValuePredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareRangePredicate CompareRange(TeamPlayerFieldIndex indexOfField, string objectAlias, bool negate, params object[] values)
		{
			return new FieldCompareRangePredicate(EntityFieldFactory.Create(indexOfField), objectAlias, negate, values);
		}
		#endregion

		#region FieldCompareRangePredicate creators (4 per typed view type)

		#endregion

		#region FieldCompareExpressionPredicate creators (4 per entity type)

		/// <summary>FieldCompareExpressionPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for Aspnet_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Aspnet_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for Cs_UsersEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(Cs_UsersFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for FieldEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for FieldEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for FieldEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for FieldEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(FieldFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for GameEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for GameEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for GameEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for GameEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(GameFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for LeagueEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for LeagueEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for LeagueEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for LeagueEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LeagueFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for LocationEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for LocationEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for LocationEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for LocationEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(LocationFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for PlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for PlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for PlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for PlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(PlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for RoleEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for RoleEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for RoleEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for RoleEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(RoleFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for TeamEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for TeamEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for TeamEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for TeamEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		/// <summary>FieldCompareExpressionPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, negate);
		}

		/// <summary>FieldCompareExpressionPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias);
		}
		
		/// <summary>FieldCompareExpressionPredicate factory for TeamPlayerEntity.</summary>
		public static FieldCompareExpressionPredicate CompareExpression(TeamPlayerFieldIndex indexOfField, ComparisonOperator operatorToUse, IExpression expressionToCompareWith, string objectAlias, bool negate)
		{
			return new FieldCompareExpressionPredicate(EntityFieldFactory.Create(indexOfField), operatorToUse, expressionToCompareWith, objectAlias, negate);
		}
		#endregion

		#region FieldCompareExpressionPredicate creators (4 per typed view type)

		#endregion

		#region Included Code

		#endregion
	}
}
